#include <stdio.h>
#include <algorithm>

template <class T>
struct Point
{ 
    T x, y; 
};

template <class T>
T gcd(T a, T b)
{
    if (a == 0)
        return b;
    if (b == 0)
        return a;

    T r;
    while ((r = a % b) != 0)
    {
        a = b;
        b = r;
    }
    return b;
}

/* Represents the fraction p / q, where
 *   i, integer n is represented by (n, 1);
 *  ii, fractions are represented by q > 0, p, q coprime;
 * iii, +/-infinity is represented by (+/-1, 0);
 *  iv, NaN is represented by (0, 0).
 */
template <class T>
struct Fraction
{
    T p, q;
    Fraction() { }
    Fraction(T numerator, T denominator) : p(numerator), q(denominator)
    {
        if (q == 0)
        {
            p = (p > 0)? 1 : (p < 0)? -1 : 0;
        }
        else
        {
            T g = gcd(p, q);
            if (g != 1 && g != -1)
            {
                p /= g;
                q /= g;
            }
            if (q < 0)
            {
                p = -p;
                q = -q;
            }
        }
    }
    bool operator == (const Fraction &other) const
    {
        return p == other.p && q == other.q;
    }
};

template <class T>
bool fraction_lexical_comparer(const Fraction<T> &a, const Fraction<T> &b)
{
    return (a.p < b.p) || (a.p == b.p && a.q < b.q);
}

#define MAX_N 200
static Point<short> points[MAX_N];
static Fraction<short> slopes[MAX_N*(MAX_N-1)/2];

int main()
{
    int n;
    scanf("%d", &n);

    /* Read points. */
    for (int i = 0; i < n; i++)
    {
        int x, y;
        scanf("%d %d", &x, &y);
        points[i].x = (short)x;
        points[i].y = (short)y;
    }

    /* Compute slope of each pair of points. */
    int k = 0;
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
        {
            short dx = points[j].x - points[i].x;
            short dy = points[j].y - points[i].y;
            if (dx == 0)
                slopes[k++] = Fraction<short>(1, 0); /* avoid +/-INF diff */
            else
                slopes[k++] = Fraction<short>(dy, dx);
        }

    /* Sort the slopes lexically. */
    std::sort(slopes + 0, slopes + k, fraction_lexical_comparer<short>);

    /* Count distinct items. */
    Fraction<short> f = slopes[0];
    int count = 1;
    for (int i = 1; i < k; i++)
    {
        if (!(slopes[i] == f))
        {
            ++count;
            f = slopes[i];
        }
    }
    printf("%d\n", count);
    return 0;
}
